import java.util.Arrays;

public class demo {
    //    给定一个整型数组, 将所有的偶数放在前半部分, 将所有的奇数放在数组后半部分
    public static void transform(int[] arr){
        int left = 0;
        int right = arr.length-1;
        while (left < right){
            while (arr[left] % 2 == 0 && left < right){
                left++;
            }
            while (arr[right] % 2 == 1 && left < right){
                right--;
            }
            int tmp = arr[left];
            arr[left] = arr[right];
            arr[right] = tmp;
        }
    }
    public static void main3(String[] args) {
        int[] arr = {1,2,3,4,5,6};
        System.out.println(Arrays.toString(arr));
        transform(arr);
        System.out.println(Arrays.toString(arr));
    }













    //    给定一个数组, 将里面的元素逆序排列
//    设定两个下标, 分别指向第一个元素和最后一个元素.
//    交换两个位置的元素.然后让前一个下标自增, 后一个下标自减, 循环继续即可.
    public static void reverse(int[] arr){
        int left = 0;
        int right = arr.length-1;
        while (left < right){
            int tmp = arr[left];
            arr[left] = arr[right];
            arr[right] = tmp;
            left++;
            right--;
        }

    }
    public static void main2(String[] args) {
        int[] arr = {1,2,3,4,5};
        System.out.println(Arrays.toString(arr));
        reverse(arr);
        System.out.println(Arrays.toString(arr));
    }













    public static void main1(String[] args) {
        int[] arr = new int[10];
        System.out.println(Arrays.toString(arr));
        Arrays.fill(arr,99); //数组填充 全部填充
        System.out.println(Arrays.toString(arr));
        Arrays.fill(arr, 2, 5, 55);//填充合适的位置  左闭右开{2,5)
        System.out.println(Arrays.toString(arr));
    }













    //    数组的拷贝
    public static int[] copyArr(int[] arr){
        int[] copy = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            copy[i] = arr[i];
        }
        return copy;
    }
    public static void main5(String[] args) {
        int[] arr = {1,2,3,4,5,6};
        System.out.println(Arrays.toString(arr));
        System.out.println("1.自定义数组拷贝");
        int[] ret = copyArr(arr);
        System.out.println(Arrays.toString(ret));

//        也有内置函数拷贝
        System.out.println("2.内置函数拷贝");
        int[] ret1 = Arrays.copyOf(arr, arr.length);
        System.out.println(Arrays.toString(ret1));

//        可以将后面的 arr.length*2 会使得数组长度变长
        System.out.println("将arr.length*2");
        int[] ret2 = Arrays.copyOf(arr,arr.length*2);
        System.out.println(Arrays.toString(ret2));

        System.out.println("copyOfRange方法");
        int[] ret3 = Arrays.copyOfRange(arr,2,5);
        System.out.println(Arrays.toString(ret3));
//        在这里可以鼠标点击 想要查看的函数 点击Ctrl+鼠标左键  就可以查看该函数的源码
//
        System.out.println("3.arraycopy方法");
//        arraycopy方法有5个参数
//        源数组，
//        从源数组的这个位置开始拷贝，
//        拷贝到哪里（copy），
//        copy什么位置开始拷贝，
//        拷贝的长度
//        注：在使用的时候不能超过边界 不然会报错
        int[] copy = new int[arr.length];
        System.arraycopy(arr,0,copy,0,arr.length);
        System.out.println(Arrays.toString(copy));
//        arraycopy点Ctrl+鼠标左键查看源码的时候 会发现该方法没有实现
//        因为 所有被native修饰的方法 都已经被C++/C实现了
//        这些方法的特点：快

        System.out.println("4.clone()方法");
        int[] ret4 = arr.clone();
        System.out.println(Arrays.toString(ret4));




//        理解 深拷贝 浅拷贝 引用拷贝
    }










    //    二维数组

    public static void main6(String[] args) {
//        二维数组的创建 两行三列
        int[][] arr1 = {{1,2,3},{4,5,6}};
        int[][] arr2 = new int[][]{{1,2,3},{4,5,6}};
        int[][] arr3 = new int[2][3];
    }






    //        打印二维数组数组(特殊的一维数组)
    public static void main7(String[] args) {
        System.out.println("=====for的普通打印======");
        int[][] arr = {{1,2,3},{4,5,6}};
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
//        这种打印方式 比较麻烦 每次都需要知道二维数组的行和列

        System.out.println("=====利用.length 来打印======");
        System.out.println(arr.length);//可以求行
        System.out.println(arr[0].length);//可以求列
//        所以我们可以这样打印
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }

//        利用foreach打印
        System.out.println("=====利用foreach打印======");
        for (int[] x: arr) {
            for (int y: x) {
                System.out.print(y + " ");
            }
            System.out.println();
        }

//        通过方法打印Arrays
        System.out.println("======通过方法打印Arrays.deepToString()=====");
        System.out.println(Arrays.deepToString(arr));
    }








//        特殊的二维数组   注 Java二维数组的存储空间实际上并不是连续的
    public static void main8(String[] args) {
        int[][] arr1 = {{1,2},{4,5,6}};
        for (int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr1[i].length; j++) {
                System.out.print(arr1[i][j] + " ");
            }
            System.out.println();
        }
//        此时打印结果是
//        1 2
//        4 5 6
        System.out.println("============");
//        在C语言中 二维数组可以省略行
//        在java中 二维数组不可以省略行


//        int[][] arr2 = new int[2][];
//        for (int i = 0; i < arr2.length; i++) {
//            for (int j = 0; j < arr2[i].length; j++) {//这一行的arr2[i].length报错
//                System.out.print(arr2[i][j] + " ");
//            }
//            System.out.println();


//            在二维数组组成中 虽然有两行 但是每行在栈上存放的地址为null
        }








//        不规则二维数组
    public static void main(String[] args) {
        int[][] arr = new int[2][];
        arr[0] = new int[3];
        arr[1] = new int[2];
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }

//        此时打印结果是
//        0 0 0
//        0 0

//        注 Java二维数组的存储空间实际上并不是连续的
    }


}


